home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / share / arm / util / connections.py < prev    next >
Encoding:
Python Source  |  2012-05-18  |  27.5 KB  |  766 lines
  1. """
  2. Fetches connection data (IP addresses and ports) associated with a given
  3. process. This sort of data can be retrieved via a variety of common *nix
  4. utilities:
  5. - netstat   netstat -np | grep "ESTABLISHED <pid>/<process>"
  6. - sockstat  sockstat | egrep "<process> *<pid>.*ESTABLISHED"
  7. - lsof      lsof -wnPi | egrep "^<process> *<pid>.*((UDP.*)|(\(ESTABLISHED\)))"
  8. - ss        ss -nptu | grep "ESTAB.*\"<process>\",<pid>"
  9.  
  10. all queries dump its stderr (directing it to /dev/null). Results include UDP
  11. and established TCP connections.
  12.  
  13. FreeBSD lacks support for the needed netstat flags and has a completely
  14. different program for 'ss'. However, lsof works and there's a couple other
  15. options that perform even better (thanks to Fabian Keil and Hans Schnehl):
  16. - sockstat    sockstat -4c | grep '<process> *<pid>'
  17. - procstat    procstat -f <pid> | grep TCP | grep -v 0.0.0.0:0
  18. """
  19.  
  20. import os
  21. import time
  22. import threading
  23.  
  24. from util import enum, log, procTools, sysTools
  25.  
  26. # enums for connection resolution utilities
  27. Resolver = enum.Enum(("PROC", "proc"),
  28.                      ("NETSTAT", "netstat"),
  29.                      ("SS", "ss"),
  30.                      ("LSOF", "lsof"),
  31.                      ("SOCKSTAT", "sockstat"),
  32.                      ("BSD_SOCKSTAT", "sockstat (bsd)"),
  33.                      ("BSD_PROCSTAT", "procstat (bsd)"))
  34.  
  35. # If true this provides new instantiations for resolvers if the old one has
  36. # been stopped. This can make it difficult ensure all threads are terminated
  37. # when accessed concurrently.
  38. RECREATE_HALTED_RESOLVERS = False
  39.  
  40. # formatted strings for the commands to be executed with the various resolvers
  41. # options are:
  42. # n = prevents dns lookups, p = include process
  43. # output:
  44. # tcp  0  0  127.0.0.1:9051  127.0.0.1:53308  ESTABLISHED 9912/tor
  45. # *note: bsd uses a different variant ('-t' => '-p tcp', but worse an
  46. #   equivilant -p doesn't exist so this can't function)
  47. RUN_NETSTAT = "netstat -np | grep \"ESTABLISHED %s/%s\""
  48.  
  49. # n = numeric ports, p = include process, t = tcp sockets, u = udp sockets
  50. # output:
  51. # ESTAB  0  0  127.0.0.1:9051  127.0.0.1:53308  users:(("tor",9912,20))
  52. # *note: under freebsd this command belongs to a spreadsheet program
  53. RUN_SS = "ss -nptu | grep \"ESTAB.*\\\"%s\\\",%s\""
  54.  
  55. # n = prevent dns lookups, P = show port numbers (not names), i = ip only,
  56. # -w = no warnings
  57. # output:
  58. # tor  3873  atagar  45u  IPv4  40994  0t0  TCP 10.243.55.20:45724->194.154.227.109:9001 (ESTABLISHED)
  59. # 
  60. # oddly, using the -p flag via:
  61. # lsof      lsof -nPi -p <pid> | grep "^<process>.*(ESTABLISHED)"
  62. # is much slower (11-28% in tests I ran)
  63. RUN_LSOF = "lsof -wnPi | egrep \"^%s *%s.*((UDP.*)|(\\(ESTABLISHED\\)))\""
  64.  
  65. # output:
  66. # atagar  tor  3475  tcp4  127.0.0.1:9051  127.0.0.1:38942  ESTABLISHED
  67. # *note: this isn't available by default under ubuntu
  68. RUN_SOCKSTAT = "sockstat | egrep \"%s *%s.*ESTABLISHED\""
  69.  
  70. RUN_BSD_SOCKSTAT = "sockstat -4c | grep '%s *%s'"
  71. RUN_BSD_PROCSTAT = "procstat -f %s | grep TCP | grep -v 0.0.0.0:0"
  72.  
  73. RESOLVERS = []                      # connection resolvers available via the singleton constructor
  74. RESOLVER_FAILURE_TOLERANCE = 3      # number of subsequent failures before moving on to another resolver
  75. RESOLVER_SERIAL_FAILURE_MSG = "Unable to query connections with %s, trying %s"
  76. RESOLVER_FINAL_FAILURE_MSG = "All connection resolvers failed"
  77. CONFIG = {"queries.connections.minRate": 5,
  78.           "log.connResolverOptions": log.INFO,
  79.           "log.connLookupFailed": log.INFO,
  80.           "log.connLookupFailover": log.NOTICE,
  81.           "log.connLookupAbandon": log.NOTICE,
  82.           "log.connLookupRateGrowing": None,
  83.           "log.configEntryTypeError": log.NOTICE}
  84.  
  85. PORT_USAGE = {}
  86.  
  87. def loadConfig(config):
  88.   config.update(CONFIG)
  89.   
  90.   for configKey in config.getKeys():
  91.     # fetches any port.label.* values
  92.     if configKey.startswith("port.label."):
  93.       portEntry = configKey[11:]
  94.       purpose = config.get(configKey)
  95.       
  96.       divIndex = portEntry.find("-")
  97.       if divIndex == -1:
  98.         # single port
  99.         if portEntry.isdigit():
  100.           PORT_USAGE[portEntry] = purpose
  101.         else:
  102.           msg = "Port value isn't numeric for entry: %s" % configKey
  103.           log.log(CONFIG["log.configEntryTypeError"], msg)
  104.       else:
  105.         try:
  106.           # range of ports (inclusive)
  107.           minPort = int(portEntry[:divIndex])
  108.           maxPort = int(portEntry[divIndex + 1:])
  109.           if minPort > maxPort: raise ValueError()
  110.           
  111.           for port in range(minPort, maxPort + 1):
  112.             PORT_USAGE[str(port)] = purpose
  113.         except ValueError:
  114.           msg = "Unable to parse port range for entry: %s" % configKey
  115.           log.log(CONFIG["log.configEntryTypeError"], msg)
  116.  
  117. def isValidIpAddress(ipStr):
  118.   """
  119.   Returns true if input is a valid IPv4 address, false otherwise.
  120.   """
  121.   
  122.   # checks if theres four period separated values
  123.   if not ipStr.count(".") == 3: return False
  124.   
  125.   # checks that each value in the octet are decimal values between 0-255
  126.   for ipComp in ipStr.split("."):
  127.     if not ipComp.isdigit() or int(ipComp) < 0 or int(ipComp) > 255:
  128.       return False
  129.   
  130.   return True
  131.  
  132. def isIpAddressPrivate(ipAddr):
  133.   """
  134.   Provides true if the IP address belongs on the local network or belongs to
  135.   loopback, false otherwise. These include:
  136.   Private ranges: 10.*, 172.16.* - 172.31.*, 192.168.*
  137.   Loopback: 127.*
  138.   
  139.   Arguments:
  140.     ipAddr - IP address to be checked
  141.   """
  142.   
  143.   # checks for any of the simple wildcard ranges
  144.   if ipAddr.startswith("10.") or ipAddr.startswith("192.168.") or ipAddr.startswith("127."):
  145.     return True
  146.   
  147.   # checks for the 172.16.* - 172.31.* range
  148.   if ipAddr.startswith("172.") and ipAddr.count(".") == 3:
  149.     secondOctet = ipAddr[4:ipAddr.find(".", 4)]
  150.     
  151.     if secondOctet.isdigit() and int(secondOctet) >= 16 and int(secondOctet) <= 31:
  152.       return True
  153.   
  154.   return False
  155.  
  156. def ipToInt(ipAddr):
  157.   """
  158.   Provides an integer representation of the ip address, suitable for sorting.
  159.   
  160.   Arguments:
  161.     ipAddr - ip address to be converted
  162.   """
  163.   
  164.   total = 0
  165.   
  166.   for comp in ipAddr.split("."):
  167.     total *= 255
  168.     total += int(comp)
  169.   
  170.   return total
  171.  
  172. def getPortUsage(port):
  173.   """
  174.   Provides the common use of a given port. If no useage is known then this
  175.   provides None.
  176.   
  177.   Arguments:
  178.     port - port number to look up
  179.   """
  180.   
  181.   return PORT_USAGE.get(port)
  182.  
  183. def getResolverCommand(resolutionCmd, processName, processPid = ""):
  184.   """
  185.   Provides the command that would be processed for the given resolver type.
  186.   This raises a ValueError if either the resolutionCmd isn't recognized or a
  187.   pid was requited but not provided.
  188.   
  189.   Arguments:
  190.     resolutionCmd - command to use in resolving the address
  191.     processName   - name of the process for which connections are fetched
  192.     processPid    - process ID (this helps improve accuracy)
  193.   """
  194.   
  195.   if not processPid:
  196.     # the pid is required for procstat resolution
  197.     if resolutionCmd == Resolver.BSD_PROCSTAT:
  198.       raise ValueError("procstat resolution requires a pid")
  199.     
  200.     # if the pid was undefined then match any in that field
  201.     processPid = "[0-9]*"
  202.   
  203.   if resolutionCmd == Resolver.PROC: return ""
  204.   elif resolutionCmd == Resolver.NETSTAT: return RUN_NETSTAT % (processPid, processName)
  205.   elif resolutionCmd == Resolver.SS: return RUN_SS % (processName, processPid)
  206.   elif resolutionCmd == Resolver.LSOF: return RUN_LSOF % (processName, processPid)
  207.   elif resolutionCmd == Resolver.SOCKSTAT: return RUN_SOCKSTAT % (processName, processPid)
  208.   elif resolutionCmd == Resolver.BSD_SOCKSTAT: return RUN_BSD_SOCKSTAT % (processName, processPid)
  209.   elif resolutionCmd == Resolver.BSD_PROCSTAT: return RUN_BSD_PROCSTAT % processPid
  210.   else: raise ValueError("Unrecognized resolution type: %s" % resolutionCmd)
  211.  
  212. def getConnections(resolutionCmd, processName, processPid = ""):
  213.   """
  214.   Retrieves a list of the current connections for a given process, providing a
  215.   tuple list of the form:
  216.   [(local_ipAddr1, local_port1, foreign_ipAddr1, foreign_port1), ...]
  217.   this raises an IOError if no connections are available or resolution fails
  218.   (in most cases these appear identical). Common issues include:
  219.     - insufficient permissions
  220.     - resolution command is unavailable
  221.     - usage of the command is non-standard (particularly an issue for BSD)
  222.   
  223.   Arguments:
  224.     resolutionCmd - command to use in resolving the address
  225.     processName   - name of the process for which connections are fetched
  226.     processPid    - process ID (this helps improve accuracy)
  227.   """
  228.   
  229.   if resolutionCmd == Resolver.PROC:
  230.     # Attempts resolution via checking the proc contents.
  231.     if not processPid:
  232.       raise ValueError("proc resolution requires a pid")
  233.     
  234.     try:
  235.       return procTools.getConnections(processPid)
  236.     except Exception, exc:
  237.       raise IOError(str(exc))
  238.   else:
  239.     # Queries a resolution utility (netstat, lsof, etc). This raises an
  240.     # IOError if the command fails or isn't available.
  241.     cmd = getResolverCommand(resolutionCmd, processName, processPid)
  242.     results = sysTools.call(cmd)
  243.     
  244.     if not results: raise IOError("No results found using: %s" % cmd)
  245.     
  246.     # parses results for the resolution command
  247.     conn = []
  248.     for line in results:
  249.       if resolutionCmd == Resolver.LSOF:
  250.         # Different versions of lsof have different numbers of columns, so
  251.         # stripping off the optional 'established' entry so we can just use
  252.         # the last one.
  253.         comp = line.replace("(ESTABLISHED)", "").strip().split()
  254.       else: comp = line.split()
  255.       
  256.       if resolutionCmd == Resolver.NETSTAT:
  257.         localIp, localPort = comp[3].split(":")
  258.         foreignIp, foreignPort = comp[4].split(":")
  259.       elif resolutionCmd == Resolver.SS:
  260.         localIp, localPort = comp[4].split(":")
  261.         foreignIp, foreignPort = comp[5].split(":")
  262.       elif resolutionCmd == Resolver.LSOF:
  263.         local, foreign = comp[-1].split("->")
  264.         localIp, localPort = local.split(":")
  265.         foreignIp, foreignPort = foreign.split(":")
  266.       elif resolutionCmd == Resolver.SOCKSTAT:
  267.         localIp, localPort = comp[4].split(":")
  268.         foreignIp, foreignPort = comp[5].split(":")
  269.       elif resolutionCmd == Resolver.BSD_SOCKSTAT:
  270.         localIp, localPort = comp[5].split(":")
  271.         foreignIp, foreignPort = comp[6].split(":")
  272.       elif resolutionCmd == Resolver.BSD_PROCSTAT:
  273.         localIp, localPort = comp[9].split(":")
  274.         foreignIp, foreignPort = comp[10].split(":")
  275.       
  276.       conn.append((localIp, localPort, foreignIp, foreignPort))
  277.     
  278.     return conn
  279.  
  280. def isResolverAlive(processName, processPid = ""):
  281.   """
  282.   This provides true if a singleton resolver instance exists for the given
  283.   process/pid combination, false otherwise.
  284.   
  285.   Arguments:
  286.     processName - name of the process being checked
  287.     processPid  - pid of the process being checked, if undefined this matches
  288.                   against any resolver with the process name
  289.   """
  290.   
  291.   for resolver in RESOLVERS:
  292.     if not resolver._halt and resolver.processName == processName and (not processPid or resolver.processPid == processPid):
  293.       return True
  294.   
  295.   return False
  296.  
  297. def getResolver(processName, processPid = "", alias=None):
  298.   """
  299.   Singleton constructor for resolver instances. If a resolver already exists
  300.   for the process then it's returned. Otherwise one is created and started.
  301.   
  302.   Arguments:
  303.     processName - name of the process being resolved
  304.     processPid  - pid of the process being resolved, if undefined this matches
  305.                   against any resolver with the process name
  306.     alias       - alternative handle under which the resolver can be requested
  307.   """
  308.   
  309.   # check if one's already been created
  310.   requestHandle = alias if alias else processName
  311.   haltedIndex = -1 # old instance of this resolver with the _halt flag set
  312.   for i in range(len(RESOLVERS)):
  313.     resolver = RESOLVERS[i]
  314.     if resolver.handle == requestHandle and (not processPid or resolver.processPid == processPid):
  315.       if resolver._halt and RECREATE_HALTED_RESOLVERS: haltedIndex = i
  316.       else: return resolver
  317.   
  318.   # make a new resolver
  319.   r = ConnectionResolver(processName, processPid, handle = requestHandle)
  320.   r.start()
  321.   
  322.   # overwrites halted instance of this resolver if it exists, otherwise append
  323.   if haltedIndex == -1: RESOLVERS.append(r)
  324.   else: RESOLVERS[haltedIndex] = r
  325.   return r
  326.  
  327. def getSystemResolvers(osType = None):
  328.   """
  329.   Provides the types of connection resolvers available on this operating
  330.   system.
  331.   
  332.   Arguments:
  333.     osType - operating system type, fetched from the os module if undefined
  334.   """
  335.   
  336.   if osType == None: osType = os.uname()[0]
  337.   
  338.   if osType == "FreeBSD":
  339.     resolvers = [Resolver.BSD_SOCKSTAT, Resolver.BSD_PROCSTAT, Resolver.LSOF]
  340.   elif osType in ("OpenBSD", "Darwin"):
  341.     resolvers = [Resolver.LSOF]
  342.   else:
  343.     resolvers = [Resolver.NETSTAT, Resolver.SOCKSTAT, Resolver.LSOF, Resolver.SS]
  344.   
  345.   # proc resolution, by far, outperforms the others so defaults to this is able
  346.   if procTools.isProcAvailable():
  347.     resolvers = [Resolver.PROC] + resolvers
  348.   
  349.   return resolvers
  350.  
  351. class ConnectionResolver(threading.Thread):
  352.   """
  353.   Service that periodically queries for a process' current connections. This
  354.   provides several benefits over on-demand queries:
  355.   - queries are non-blocking (providing cached results)
  356.   - falls back to use different resolution methods in case of repeated failures
  357.   - avoids overly frequent querying of connection data, which can be demanding
  358.     in terms of system resources
  359.   
  360.   Unless an overriding method of resolution is requested this defaults to
  361.   choosing a resolver the following way:
  362.   
  363.   - Checks the current PATH to determine which resolvers are available. This
  364.     uses the first of the following that's available:
  365.       netstat, ss, lsof (picks netstat if none are found)
  366.   
  367.   - Attempts to resolve using the selection. Single failures are logged at the
  368.     INFO level, and a series of failures at NOTICE. In the later case this
  369.     blacklists the resolver, moving on to the next. If all resolvers fail this
  370.     way then resolution's abandoned and logs a WARN message.
  371.   
  372.   The time between resolving connections, unless overwritten, is set to be
  373.   either five seconds or ten times the runtime of the resolver (whichever is
  374.   larger). This is to prevent systems either strapped for resources or with a
  375.   vast number of connections from being burdened too heavily by this daemon.
  376.   
  377.   Parameters:
  378.     processName       - name of the process being resolved
  379.     processPid        - pid of the process being resolved
  380.     resolveRate       - minimum time between resolving connections (in seconds,
  381.                         None if using the default)
  382.     * defaultRate     - default time between resolving connections
  383.     lastLookup        - time connections were last resolved (unix time, -1 if
  384.                         no resolutions have yet been successful)
  385.     overwriteResolver - method of resolution (uses default if None)
  386.     * defaultResolver - resolver used by default (None if all resolution
  387.                         methods have been exhausted)
  388.     resolverOptions   - resolvers to be cycled through (differ by os)
  389.     
  390.     * read-only
  391.   """
  392.   
  393.   def __init__(self, processName, processPid = "", resolveRate = None, handle = None):
  394.     """
  395.     Initializes a new resolver daemon. When no longer needed it's suggested
  396.     that this is stopped.
  397.     
  398.     Arguments:
  399.       processName - name of the process being resolved
  400.       processPid  - pid of the process being resolved
  401.       resolveRate - time between resolving connections (in seconds, None if
  402.                     chosen dynamically)
  403.       handle      - name used to query this resolver, this is the processName
  404.                     if undefined
  405.     """
  406.     
  407.     threading.Thread.__init__(self)
  408.     self.setDaemon(True)
  409.     
  410.     self.processName = processName
  411.     self.processPid = processPid
  412.     self.resolveRate = resolveRate
  413.     self.handle = handle if handle else processName
  414.     self.defaultRate = CONFIG["queries.connections.minRate"]
  415.     self.lastLookup = -1
  416.     self.overwriteResolver = None
  417.     self.defaultResolver = Resolver.PROC
  418.     
  419.     osType = os.uname()[0]
  420.     self.resolverOptions = getSystemResolvers(osType)
  421.     
  422.     log.log(CONFIG["log.connResolverOptions"], "Operating System: %s, Connection Resolvers: %s" % (osType, ", ".join(self.resolverOptions)))
  423.     
  424.     # sets the default resolver to be the first found in the system's PATH
  425.     # (left as netstat if none are found)
  426.     for resolver in self.resolverOptions:
  427.       # Resolver strings correspond to their command with the exception of bsd
  428.       # resolvers.
  429.       resolverCmd = resolver.replace(" (bsd)", "")
  430.       
  431.       if resolver == Resolver.PROC or sysTools.isAvailable(resolverCmd):
  432.         self.defaultResolver = resolver
  433.         break
  434.     
  435.     self._connections = []        # connection cache (latest results)
  436.     self._resolutionCounter = 0   # number of successful connection resolutions
  437.     self._isPaused = False
  438.     self._halt = False            # terminates thread if true
  439.     self._cond = threading.Condition()  # used for pausing the thread
  440.     self._subsiquentFailures = 0  # number of failed resolutions with the default in a row
  441.     self._resolverBlacklist = []  # resolvers that have failed to resolve
  442.     
  443.     # Number of sequential times the threshold rate's been too low. This is to
  444.     # avoid having stray spikes up the rate.
  445.     self._rateThresholdBroken = 0
  446.   
  447.   def getOverwriteResolver(self):
  448.     """
  449.     Provides the resolver connection resolution is forced to use. This returns
  450.     None if it's dynamically determined.
  451.     """
  452.     
  453.     return self.overwriteResolver
  454.      
  455.   def setOverwriteResolver(self, overwriteResolver):
  456.     """
  457.     Sets the resolver used for connection resolution, if None then this is
  458.     automatically determined based on what is available.
  459.     
  460.     Arguments:
  461.       overwriteResolver - connection resolver to be used
  462.     """
  463.     
  464.     self.overwriteResolver = overwriteResolver
  465.   
  466.   def run(self):
  467.     while not self._halt:
  468.       minWait = self.resolveRate if self.resolveRate else self.defaultRate
  469.       timeSinceReset = time.time() - self.lastLookup
  470.       
  471.       if self._isPaused or timeSinceReset < minWait:
  472.         sleepTime = max(0.2, minWait - timeSinceReset)
  473.         
  474.         self._cond.acquire()
  475.         if not self._halt: self._cond.wait(sleepTime)
  476.         self._cond.release()
  477.         
  478.         continue # done waiting, try again
  479.       
  480.       isDefault = self.overwriteResolver == None
  481.       resolver = self.defaultResolver if isDefault else self.overwriteResolver
  482.       
  483.       # checks if there's nothing to resolve with
  484.       if not resolver:
  485.         self.lastLookup = time.time() # avoids a busy wait in this case
  486.         continue
  487.       
  488.       try:
  489.         resolveStart = time.time()
  490.         connResults = getConnections(resolver, self.processName, self.processPid)
  491.         lookupTime = time.time() - resolveStart
  492.         
  493.         self._connections = connResults
  494.         self._resolutionCounter += 1
  495.         
  496.         newMinDefaultRate = 100 * lookupTime
  497.         if self.defaultRate < newMinDefaultRate:
  498.           if self._rateThresholdBroken >= 3:
  499.             # adding extra to keep the rate from frequently changing
  500.             self.defaultRate = newMinDefaultRate + 0.5
  501.             
  502.             msg = "connection lookup time increasing to %0.1f seconds per call" % self.defaultRate
  503.             log.log(CONFIG["log.connLookupRateGrowing"], msg)
  504.           else: self._rateThresholdBroken += 1
  505.         else: self._rateThresholdBroken = 0
  506.         
  507.         if isDefault: self._subsiquentFailures = 0
  508.       except (ValueError, IOError), exc:
  509.         # this logs in a couple of cases:
  510.         # - special failures noted by getConnections (most cases are already
  511.         # logged via sysTools)
  512.         # - note fail-overs for default resolution methods
  513.         if str(exc).startswith("No results found using:"):
  514.           log.log(CONFIG["log.connLookupFailed"], str(exc))
  515.         
  516.         if isDefault:
  517.           self._subsiquentFailures += 1
  518.           
  519.           if self._subsiquentFailures >= RESOLVER_FAILURE_TOLERANCE:
  520.             # failed several times in a row - abandon resolver and move on to another
  521.             self._resolverBlacklist.append(resolver)
  522.             self._subsiquentFailures = 0
  523.             
  524.             # pick another (non-blacklisted) resolver
  525.             newResolver = None
  526.             for r in self.resolverOptions:
  527.               if not r in self._resolverBlacklist:
  528.                 newResolver = r
  529.                 break
  530.             
  531.             if newResolver:
  532.               # provide notice that failures have occurred and resolver is changing
  533.               msg = RESOLVER_SERIAL_FAILURE_MSG % (resolver, newResolver)
  534.               log.log(CONFIG["log.connLookupFailover"], msg)
  535.             else:
  536.               # exhausted all resolvers, give warning
  537.               log.log(CONFIG["log.connLookupAbandon"], RESOLVER_FINAL_FAILURE_MSG)
  538.             
  539.             self.defaultResolver = newResolver
  540.       finally:
  541.         self.lastLookup = time.time()
  542.   
  543.   def getConnections(self):
  544.     """
  545.     Provides the last queried connection results, an empty list if resolver
  546.     has been halted.
  547.     """
  548.     
  549.     if self._halt: return []
  550.     else: return list(self._connections)
  551.   
  552.   def getResolutionCount(self):
  553.     """
  554.     Provides the number of successful resolutions so far. This can be used to
  555.     determine if the connection results are new for the caller or not.
  556.     """
  557.     
  558.     return self._resolutionCounter
  559.   
  560.   def getPid(self):
  561.     """
  562.     Provides the pid used to narrow down connection resolution. This is an
  563.     empty string if undefined.
  564.     """
  565.     
  566.     return self.processPid
  567.   
  568.   def setPid(self, processPid):
  569.     """
  570.     Sets the pid used to narrow down connection resultions.
  571.     
  572.     Arguments:
  573.       processPid - pid for the process we're fetching connections for
  574.     """
  575.     
  576.     self.processPid = processPid
  577.   
  578.   def setPaused(self, isPause):
  579.     """
  580.     Allows or prevents further connection resolutions (this still makes use of
  581.     cached results).
  582.     
  583.     Arguments:
  584.       isPause - puts a freeze on further resolutions if true, allows them to
  585.                 continue otherwise
  586.     """
  587.     
  588.     if isPause == self._isPaused: return
  589.     self._isPaused = isPause
  590.   
  591.   def stop(self):
  592.     """
  593.     Halts further resolutions and terminates the thread.
  594.     """
  595.     
  596.     self._cond.acquire()
  597.     self._halt = True
  598.     self._cond.notifyAll()
  599.     self._cond.release()
  600.  
  601. class AppResolver:
  602.   """
  603.   Provides the names and pids of appliations attached to the given ports. This
  604.   stops attempting to query if it fails three times without successfully
  605.   getting lsof results.
  606.   """
  607.   
  608.   def __init__(self, scriptName = "python"):
  609.     """
  610.     Constructs a resolver instance.
  611.     
  612.     Arguments:
  613.       scriptName - name by which to all our own entries
  614.     """
  615.     
  616.     self.scriptName = scriptName
  617.     self.queryResults = {}
  618.     self.resultsLock = threading.RLock()
  619.     self._cond = threading.Condition()  # used for pausing when waiting for results
  620.     self.isResolving = False  # flag set if we're in the process of making a query
  621.     self.failureCount = 0     # -1 if we've made a successful query
  622.   
  623.   def getResults(self, maxWait=0):
  624.     """
  625.     Provides the last queried results. If we're in the process of making a
  626.     query then we can optionally block for a time to see if it finishes.
  627.     
  628.     Arguments:
  629.       maxWait - maximum second duration to block on getting results before
  630.                 returning
  631.     """
  632.     
  633.     self._cond.acquire()
  634.     if self.isResolving and maxWait > 0:
  635.       self._cond.wait(maxWait)
  636.     self._cond.release()
  637.     
  638.     self.resultsLock.acquire()
  639.     results = dict(self.queryResults)
  640.     self.resultsLock.release()
  641.     
  642.     return results
  643.   
  644.   def resolve(self, ports):
  645.     """
  646.     Queues the given listing of ports to be resolved. This clears the last set
  647.     of results when completed.
  648.     
  649.     Arguments:
  650.       ports - list of ports to be resolved to applications
  651.     """
  652.     
  653.     if self.failureCount < 3:
  654.       self.isResolving = True
  655.       t = threading.Thread(target = self._queryApplications, kwargs = {"ports": ports})
  656.       t.setDaemon(True)
  657.       t.start()
  658.   
  659.   def _queryApplications(self, ports=[]):
  660.     """
  661.     Performs an lsof lookup on the given ports to get the command/pid tuples.
  662.     
  663.     Arguments:
  664.       ports - list of ports to be resolved to applications
  665.     """
  666.     
  667.     # atagar@fenrir:~/Desktop/arm$ lsof -i tcp:51849 -i tcp:37277
  668.     # COMMAND  PID   USER   FD   TYPE DEVICE SIZE/OFF NODE NAME
  669.     # tor     2001 atagar   14u  IPv4  14048      0t0  TCP localhost:9051->localhost:37277 (ESTABLISHED)
  670.     # tor     2001 atagar   15u  IPv4  22024      0t0  TCP localhost:9051->localhost:51849 (ESTABLISHED)
  671.     # python  2462 atagar    3u  IPv4  14047      0t0  TCP localhost:37277->localhost:9051 (ESTABLISHED)
  672.     # python  3444 atagar    3u  IPv4  22023      0t0  TCP localhost:51849->localhost:9051 (ESTABLISHED)
  673.     
  674.     if not ports:
  675.       self.resultsLock.acquire()
  676.       self.queryResults = {}
  677.       self.isResolving = False
  678.       self.resultsLock.release()
  679.       
  680.       # wakes threads waiting on results
  681.       self._cond.acquire()
  682.       self._cond.notifyAll()
  683.       self._cond.release()
  684.       
  685.       return
  686.     
  687.     results = {}
  688.     lsofArgs = []
  689.     
  690.     # Uses results from the last query if we have any, otherwise appends the
  691.     # port to the lsof command. This has the potential for persisting dirty
  692.     # results but if we're querying by the dynamic port on the local tcp
  693.     # connections then this should be very rare (and definitely worth the
  694.     # chance of being able to skip an lsof query altogether).
  695.     for port in ports:
  696.       if port in self.queryResults:
  697.         results[port] = self.queryResults[port]
  698.       else: lsofArgs.append("-i tcp:%s" % port)
  699.     
  700.     if lsofArgs:
  701.       lsofResults = sysTools.call("lsof -nP " + " ".join(lsofArgs))
  702.     else: lsofResults = None
  703.     
  704.     if not lsofResults and self.failureCount != -1:
  705.       # lsof query failed and we aren't yet sure if it's possible to
  706.       # successfully get results on this platform
  707.       self.failureCount += 1
  708.       self.isResolving = False
  709.       return
  710.     elif lsofResults:
  711.       # (iPort, oPort) tuple for our own process, if it was fetched
  712.       ourConnection = None
  713.       
  714.       for line in lsofResults:
  715.         lineComp = line.split()
  716.         
  717.         if len(lineComp) == 10 and lineComp[9] == "(ESTABLISHED)":
  718.           cmd, pid, _, _, _, _, _, _, portMap, _ = lineComp
  719.           
  720.           if "->" in portMap:
  721.             iPort, oPort = portMap.split("->")
  722.             iPort = iPort.split(":")[1]
  723.             oPort = oPort.split(":")[1]
  724.             
  725.             # entry belongs to our own process
  726.             if pid == str(os.getpid()):
  727.               cmd = self.scriptName
  728.               ourConnection = (iPort, oPort)
  729.             
  730.             if iPort.isdigit() and oPort.isdigit():
  731.               newEntry = (iPort, oPort, cmd, pid)
  732.               
  733.               # adds the entry under the key of whatever we queried it with
  734.               # (this might be both the inbound _and_ outbound ports)
  735.               for portMatch in (iPort, oPort):
  736.                 if portMatch in ports:
  737.                   if portMatch in results:
  738.                     results[portMatch].append(newEntry)
  739.                   else: results[portMatch] = [newEntry]
  740.       
  741.       # making the lsof call generated an extraneous sh entry for our own connection
  742.       if ourConnection:
  743.         for ourPort in ourConnection:
  744.           if ourPort in results:
  745.             shIndex = None
  746.             
  747.             for i in range(len(results[ourPort])):
  748.               if results[ourPort][i][2] == "sh":
  749.                 shIndex = i
  750.                 break
  751.             
  752.             if shIndex != None:
  753.               del results[ourPort][shIndex]
  754.     
  755.     self.resultsLock.acquire()
  756.     self.failureCount = -1
  757.     self.queryResults = results
  758.     self.isResolving = False
  759.     self.resultsLock.release()
  760.     
  761.     # wakes threads waiting on results
  762.     self._cond.acquire()
  763.     self._cond.notifyAll()
  764.     self._cond.release()
  765.  
  766.